package 炫彩元素类

import (
	xc "gitee.com/go_888/xcgui/xcgui/xc"
	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
)

// 编辑框(常规, 富文本, 聊天气泡).
type X结构_编辑框 struct {
	X结构_滚动视图
}

// 编辑框_创建.
//
// x: 元素x坐标.
//
// y: 元素y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// hParent: 父为窗口句柄或元素句柄.
func X创建编辑框(元素x坐标, 元素y坐标, 宽度, 高度 int32, 父窗口句柄 int) *X结构_编辑框 {
	p := &X结构_编辑框{}
	p.X设置句柄(xc.X编辑框_创建(元素x坐标, 元素y坐标, 宽度, 高度, 父窗口句柄))
	return p
}

// 编辑框_创建扩展.
//
// x: 元素x坐标.
//
// y: 元素y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// nType: 类型, Edit_Type_.
//
// hParent: 父为窗口句柄或元素句柄.
func X创建编辑框EX(元素x坐标, 元素y坐标, 宽度, 高度 int32, 类型 xcc.X编辑框类型, 父窗口句柄 int) *X结构_编辑框 {
	p := &X结构_编辑框{}
	p.X句柄 = xc.X编辑框_创建EX(元素x坐标, 元素y坐标, 宽度, 高度, 类型, 父窗口句柄)
	return p
}

// 从句柄创建对象.
func X创建编辑框并按句柄(句柄 int) *X结构_编辑框 {
	p := &X结构_编辑框{}
	p.X设置句柄(句柄)
	return p
}

// 从name创建对象, 失败返回nil.
func X创建编辑框并按名称(名称 string) *X结构_编辑框 {
	handle := xc.X取对象并按名称(名称)
	if handle > 0 {
		p := &X结构_编辑框{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID创建对象, 失败返回nil.
func X创建编辑框并按UID(UID int32) *X结构_编辑框 {
	handle := xc.X取对象并按UID(UID)
	if handle > 0 {
		p := &X结构_编辑框{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID名称创建对象, 失败返回nil.
func X创建编辑框并按UID名称(名称 string) *X结构_编辑框 {
	handle := xc.X取对象并按UID名称(名称)
	if handle > 0 {
		p := &X结构_编辑框{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 编辑框_启用自动换行.
//
// bEnable: 是否启用.
func (e *X结构_编辑框) X启用自动换行(是否启用 bool) *X结构_编辑框 {
	xc.X编辑框_启用自动换行(e.X句柄, 是否启用)
	return e
}

// 编辑框_启用只读.
//
// bEnable: 是否启用.
func (e *X结构_编辑框) X启用只读(是否启用 bool) *X结构_编辑框 {
	xc.X编辑框_启用只读(e.X句柄, 是否启用)
	return e
}

// 编辑框_启用多行.
//
// bEnable:.
func (e *X结构_编辑框) X启用多行(是否启用 bool) *X结构_编辑框 {
	xc.X编辑框_启用多行(e.X句柄, 是否启用)
	return e
}

// 编辑框_启用密码, 启用密码模式(只支持默认类型编辑框).
//
// bEnable: 是否启用.
func (e *X结构_编辑框) X启用密码(是否启用 bool) *X结构_编辑框 {
	xc.X编辑框_启用密码(e.X句柄, 是否启用)
	return e
}

// 编辑框_启用自动选择, 当获得焦点时,自动选择所有内容.
//
// bEnable: 是否启用.
func (e *X结构_编辑框) X启用自动选择(是否启用 bool) *X结构_编辑框 {
	xc.X编辑框_启用自动选择(e.X句柄, 是否启用)
	return e
}

// 编辑框_启用自动取消选择, 当失去焦点时自动取消选择.
//
// bEnable: 是否启用.
func (e *X结构_编辑框) X启用自动取消选择(是否启用 bool) *X结构_编辑框 {
	xc.X编辑框_启用自动取消选择(e.X句柄, 是否启用)
	return e
}

// 编辑框_是否只读.
func (e *X结构_编辑框) X是否只读() bool {
	return xc.X编辑框_是否只读(e.X句柄)
}

// 编辑框_是否多行.
func (e *X结构_编辑框) X是否多行() bool {
	return xc.X编辑框_是否多行(e.X句柄)
}

// 编辑框_是否密码.
func (e *X结构_编辑框) X是否密码() bool {
	return xc.X编辑框_是否密码(e.X句柄)
}

// 编辑框_是否自动换行.
func (e *X结构_编辑框) X是否自动换行() bool {
	return xc.X编辑框_是否自动换行(e.X句柄)
}

// 编辑框_判断为空.
func (e *X结构_编辑框) X判断为空() bool {
	return xc.X编辑框_是否为空(e.X句柄)
}

// 编辑框_是否在选择区域.
//
// iRow: 行索引.
//
// iCol: 列索引.
func (e *X结构_编辑框) X是否在选择区域(行索引, 列索引 int32) bool {
	return xc.X编辑框_是否在选择区域(e.X句柄, 行索引, 列索引)
}

// 编辑框_取总行数.
func (e *X结构_编辑框) X取总行数() int32 {
	return xc.X编辑框_取总行数(e.X句柄)
}

// 编辑框_取数据, 包含文本或非文本内容.
func (e *X结构_编辑框) X取数据() xc.X结构_编辑框_数据复制 {
	return xc.X编辑框_取数据(e.X句柄)
}

// 编辑框_添加数据.
//
// pData: 数据结构.
//
// styleTable: 样式表.
//
// nStyleCount: 样式数量.
func (e *X结构_编辑框) X添加数据(数据结构 *xc.X结构_编辑框_数据复制, 样式表 []uint16, 样式数量 int32) *X结构_编辑框 {
	xc.X编辑框_添加数据(e.X句柄, 数据结构, 样式表, 样式数量)
	return e
}

// 编辑框_释放数据.
func (e *X结构_编辑框) X释放数据(数据结构 *xc.X结构_编辑框_数据复制) *X结构_编辑框 {
	xc.X编辑框_释放数据(数据结构)
	return e
}

// 编辑框_置默认文本, 当内容为空时, 显示默认文本.
//
// pString: 文本内容.
func (e *X结构_编辑框) X设置默认文本(文本内容 string) *X结构_编辑框 {
	xc.X编辑框_设置默认文本(e.X句柄, 文本内容)
	return e
}

// 编辑框_置默认文本颜色.
//
// color: xc.RGBA 颜色值.
func (e *X结构_编辑框) X设置默认文本颜色(ABGR颜色值 int) *X结构_编辑框 {
	xc.X编辑框_设置默认文本颜色(e.X句柄, ABGR颜色值)
	return e
}

// 编辑框_置密码字符.
//
// ch: 字符. 使用单引号包裹的字符, 如: '#'.
func (e *X结构_编辑框) X设置密码字符(字符 uint16) *X结构_编辑框 {
	xc.X编辑框_设置密码字符(e.X句柄, 字符)
	return e
}

// 编辑框_置文本对齐, 单行模式下有效.
//
// align: 对齐方式, Edit_TextAlign_Flag_.
func (e *X结构_编辑框) X设置文本对齐(对齐方式 xcc.X编辑框文本对齐) *X结构_编辑框 {
	xc.X编辑框_设置文本对齐(e.X句柄, 对齐方式)
	return e
}

// 编辑框_置TAB空格.
//
// nSpace: 空格数量.
func (e *X结构_编辑框) X设置TAB空格(空格数量 int32) *X结构_编辑框 {
	xc.X编辑框_设置TAB空格(e.X句柄, 空格数量)
	return e
}

// 编辑框_置文本.
//
// pString: 字符串.
func (e *X结构_编辑框) X设置文本(文本 string) *X结构_编辑框 {
	xc.X编辑框_设置文本(e.X句柄, 文本)
	return e
}

// 编辑框_置文本整数.
//
// nValue: 整数值.
func (e *X结构_编辑框) X设置文本整数(整数值 int32) *X结构_编辑框 {
	xc.X编辑框_设置文本整数(e.X句柄, 整数值)
	return e
}

// 编辑框_取文本, 不包含非文本内容, 返回实际接收文本长度.
//
// pOut: 接收文本内存指针.
//
// nOutlen: 内存大小. 例: GetLength()+1 .
func (e *X结构_编辑框) X取文本(返回文本指针 *string, 返回长度 int32) int32 {
	return xc.X编辑框_取文本(e.X句柄, 返回文本指针, 返回长度)
}

// 编辑框_取文本Ex, 不包含非文本内容, 返回文本.
func (e *X结构_编辑框) X取文本Ex() string {
	var s string
	xc.X编辑框_取文本(e.X句柄, &s, xc.X编辑框_取内容长度(e.X句柄)+1)
	return s
}

// 编辑框_取选择文本Ex, 不包括非文本内容, 返回文本.
func (e *X结构_编辑框) X取选择文本Ex() string {
	var s string
	xc.X编辑框_取选择文本(e.X句柄, &s, xc.X编辑框_取选择文本长度(e.X句柄)+1)
	return s
}

// 编辑框_取文本行.
//
// iRow: 行索引.
//
// pOut: 接收文本内存指针.
//
// nOutlen: 接收文本内存块长度. 例: GetLengthRow()+1 .
func (e *X结构_编辑框) X取文本行(行索引 int32, 返回文本指针 *string, 返回长度 int32) int32 {
	return xc.X编辑框_取文本行(e.X句柄, 行索引, 返回文本指针, 返回长度)
}

// 编辑框_取文本行Ex, 返回文本.
//
// iRow: 行索引.
func (e *X结构_编辑框) X取文本行Ex(行索引 int32) string {
	var s string
	xc.X编辑框_取文本行(e.X句柄, 行索引, &s, xc.X编辑框_取内容长度行(e.X句柄, 行索引)+1)
	return s
}

// 编辑框_取内容长度, 包含非文本内容.
func (e *X结构_编辑框) X取内容长度() int32 {
	return xc.X编辑框_取内容长度(e.X句柄)
}

// 编辑框_取内容长度行, 包含非文本内容.
//
// iRow: 行索引.
func (e *X结构_编辑框) X取内容长度行(行索引 int32) int32 {
	return xc.X编辑框_取内容长度行(e.X句柄, 行索引)
}

// 编辑框_取字符, 返回指定位置字符.
//
// iRow: 行索引.
//
// iCol: 列索引.
func (e *X结构_编辑框) X取字符(行索引, 列索引 int32) rune {
	return xc.X编辑框_取字符(e.X句柄, 行索引, 列索引)
}

// 编辑框_插入文本.
//
// iRow: 行索引.
//
// iCol: 列索引.
//
// pString: 字符串.
func (e *X结构_编辑框) X插入文本(行索引, 列索引 int32, 文本 string) *X结构_编辑框 {
	xc.X编辑框_插入文本(e.X句柄, 行索引, 列索引, 文本)
	return e
}

// AddTextUser 编辑框_插入文本模拟用户操作, 自动刷新UI, 支持撤销/恢复.
//
// pString: 字符串.
func (e *X结构_编辑框) X插入文本模拟用户操作(文本 string) *X结构_编辑框 {
	xc.X编辑框_插入文本模拟用户操作(e.X句柄, 文本)
	return e
}

// 编辑框_添加文本.
//
// pString: 字符串.
func (e *X结构_编辑框) X添加文本(文本 string) *X结构_编辑框 {
	xc.X编辑框_添加文本(e.X句柄, 文本)
	return e
}

// 编辑框_添加文本扩展.
//
// pString: 字符串.
//
// iStyle: 样式索引.
func (e *X结构_编辑框) X添加文本EX(文本 string, 样式索引 int32) *X结构_编辑框 {
	xc.X编辑框_添加文本EX(e.X句柄, 文本, 样式索引)
	return e
}

// 编辑框_添加对象, 例如: 字体, 图片, UI对象, 返回样式索引.
//
// hObj: 对象句柄.
func (e *X结构_编辑框) X添加对象(对象句柄 int) int32 {
	return xc.X编辑框_添加对象(e.X句柄, 对象句柄)
}

// 编辑框_添加对象从样式, 当样式为图片时有效.
//
// iStyle: 样式索引.
func (e *X结构_编辑框) X添加对象并按样式(样式索引 int32) *X结构_编辑框 {
	xc.X编辑框_添加对象从样式(e.X句柄, 样式索引)
	return e
}

// 编辑框_添加样式, 返回样式索引.
//
// hFont_image_Obj: 字体.
//
// color: 颜色.
//
// bColor: 是否使用颜色.
func (e *X结构_编辑框) X添加样式(字体 int, 颜色 int, 是否使用颜色 bool) int32 {
	return xc.X编辑框_添加样式(e.X句柄, 字体, 颜色, 是否使用颜色)
}

// 编辑框_添加样式扩展, 返回样式索引.
//
// fontName: 字体名称.
//
// fontSize: 字体大小.
//
// fontStyle: 字体样式, FontStyle_.
//
// color: 颜色.
//
// bColor: 是否使用颜色.
func (e *X结构_编辑框) X添加样式EX(字体名称 string, 字体大小 int32, 字体样式 xcc.X字体样式, 颜色 int, 是否使用颜色 bool) int32 {
	return xc.X编辑框_添加样式EX(e.X句柄, 字体名称, 字体大小, 字体样式, 颜色, 是否使用颜色)
}

// 编辑框_取样式信息.
//
// iStyle: 样式索引.
//
// info: 返回样式信息.
func (e *X结构_编辑框) X取样式信息(样式索引 int32, 返回样式信息 *xc.X结构_编辑框_样式信息) bool {
	return xc.X编辑框_取样式信息(e.X句柄, 样式索引, 返回样式信息)
}

// 编辑框_置当前样式.
//
// iStyle: 样式索引.
func (e *X结构_编辑框) X设置当前样式(样式索引 int32) *X结构_编辑框 {
	xc.X编辑框_设置当前样式(e.X句柄, 样式索引)
	return e
}

// 编辑框_置插入符颜色.
//
// color: 颜色.
func (e *X结构_编辑框) X设置插入符颜色(颜色 int) *X结构_编辑框 {
	xc.X编辑框_设置插入符颜色(e.X句柄, 颜色)
	return e
}

// 编辑框_置插入符宽度.
//
// nWidth: 宽度.
func (e *X结构_编辑框) X设置插入符宽度(宽度 int32) *X结构_编辑框 {
	xc.X编辑框_设置插入符宽度(e.X句柄, 宽度)
	return e
}

// 编辑框_置选择背景颜色.
//
// color: xc.RGBA 颜色.
func (e *X结构_编辑框) X设置选择背景颜色(ABGR颜色 int) *X结构_编辑框 {
	xc.X编辑框_设置选择背景颜色(e.X句柄, ABGR颜色)
	return e
}

// 编辑框_置默认行高.
//
// nHeight: 行高.
func (e *X结构_编辑框) X设置默认行高(行高 int32) *X结构_编辑框 {
	xc.X编辑框_设置默认行高(e.X句柄, 行高)
	return e
}

// 编辑框_置指定行高度, 类型为 Edit_Type_Richedit 支持指定不同行高.
//
// iRow: 行索引.
//
// nHeight: 高度.
func (e *X结构_编辑框) X设置指定行高度(行索引, 高度 int32) *X结构_编辑框 {
	xc.X编辑框_设置指定行高度(e.X句柄, 行索引, 高度)
	return e
}

// SetCurPos 编辑框_置当前位置.
//
// iRow: 行索引.
func (e *X结构_编辑框) X设置当前位置(行索引 int32) bool {
	return xc.X编辑框_设置当前位置(e.X句柄, 行索引)
}

// 编辑框_取当前位置点, 返回范围位置点.
func (e *X结构_编辑框) X取当前位置点() int32 {
	return xc.X编辑框_取当前位置点(e.X句柄)
}

// 编辑框_取当前行, 返回行索引.
func (e *X结构_编辑框) X取当前行() int32 {
	return xc.X编辑框_取当前行(e.X句柄)
}

// 编辑框_取当前列, 返回列索引.
func (e *X结构_编辑框) X取当前列() int32 {
	return xc.X编辑框_取当前列(e.X句柄)
}

// 编辑框_取坐标点.
//
// iRow: 行索引.
//
// iCol: 列索引.
//
// pOut: 接收返回坐标点.
func (e *X结构_编辑框) X取坐标点(行索引, 列索引 int32, 返回坐标 *xc.X结构_坐标) *X结构_编辑框 {
	xc.X编辑框_取坐标点(e.X句柄, 行索引, 列索引, 返回坐标)
	return e
}

// 编辑框_取坐标点Ex.
//
// iRow: 行索引.
//
// iCol: 列索引.
func (e *X结构_编辑框) X取坐标点EX(行索引, 列索引 int32) xc.X结构_坐标 {
	var pt xc.X结构_坐标
	xc.X编辑框_取坐标点(e.X句柄, 行索引, 列索引, &pt)
	return pt
}

// 编辑框_自动滚动, 视图自动滚动到当前插入符位置.
func (e *X结构_编辑框) X自动滚动() bool {
	return xc.X编辑框_自动滚动(e.X句柄)
}

// 编辑框_自动滚动扩展, 视图自动滚动到指定位置.
//
// iRow: 行索引.
//
// iCol: 列索引.
func (e *X结构_编辑框) X自动滚动EX(行索引, 列索引 int32) bool {
	return xc.X编辑框_自动滚动EX(e.X句柄, 行索引, 列索引)
}

// PosToRowCol 编辑框_转换位置, 转换位置点到行列.
//
// iPos: 位置点.
//
// pInfo: 行列.
func (e *X结构_编辑框) X转换位置(位置点 int32, 行列 *xc.X结构_位置点) *X结构_编辑框 {
	xc.X编辑框_转换位置(e.X句柄, 位置点, 行列)
	return e
}

// 编辑框_选择全部.
func (e *X结构_编辑框) X选择全部() bool {
	return xc.X编辑框_选择全部(e.X句柄)
}

// 编辑框_取消选择.
func (e *X结构_编辑框) X取消选择() bool {
	return xc.X编辑框_取消选择(e.X句柄)
}

// 编辑框_删除选择内容.
func (e *X结构_编辑框) X删除选择内容() bool {
	return xc.X编辑框_删除选择内容(e.X句柄)
}

// 编辑框_置选择.
//
// iStartRow: 起始行索引.
//
// iStartCol: 起始行列索引.
//
// iEndRow: 结束行索引.
//
// iEndCol: 结束行列索引.
func (e *X结构_编辑框) X设置选择(起始行索引, 起始行列索引, 结束行索引, 结束行列索引 int32) bool {
	return xc.X编辑框_设置选择(e.X句柄, 起始行索引, 起始行列索引, 结束行索引, 结束行列索引)
}

// 编辑框_取选择文本, 不包括非文本内容, 返回接收文本内容实际长度.
//
// pOut: 接收返回文本内容.
//
// nOutLen: 接收内存大小. GetSelectTextLength()+1 .
func (e *X结构_编辑框) X取选择文本(返回文本 *string, 返回内存大小 int32) int32 {
	return xc.X编辑框_取选择文本(e.X句柄, 返回文本, 返回内存大小)
}

// 编辑框_取选择内容范围.
//
// pBegin: 起始位置.
//
// pEnd: 结束位置.
func (e *X结构_编辑框) X取选择内容范围(起始位置 *xc.X结构_位置点, 结束位置 *xc.X结构_位置点) bool {
	return xc.X编辑框_取选择内容范围(e.X句柄, 起始位置, 结束位置)
}

// 编辑框_取可视行范围.
//
// piStart: 起始行索引.
//
// piEnd: 结束行索引.
func (e *X结构_编辑框) X取可视行范围(起始行索引 *int32, 结束行索引 *int32) *X结构_编辑框 {
	xc.X编辑框_取可视行范围(e.X句柄, 起始行索引, 结束行索引)
	return e
}

// 编辑框_删除, 删除指定范围内容.
//
// iStartRow: 起始行索引.
//
// iStartCol: 起始行列索引.
//
// iEndRow: 结束行索引.
//
// iEndCol: 结束行列索引.
func (e *X结构_编辑框) X删除(起始行索引, 起始行列索引, 结束行索引, 结束行列索引 int32) bool {
	return xc.X编辑框_删除(e.X句柄, 起始行索引, 起始行列索引, 结束行索引, 结束行列索引)
}

// 编辑框_删除行.
//
// iRow: 行索引.
func (e *X结构_编辑框) X删除行(行索引 int32) bool {
	return xc.X编辑框_删除行(e.X句柄, 行索引)
}

// 编辑框_剪贴板剪切.
func (e *X结构_编辑框) X剪贴板剪切() bool {
	return xc.X编辑框_剪贴板剪切(e.X句柄)
}

// 编辑框_剪贴板复制.
func (e *X结构_编辑框) X剪贴板复制() bool {
	return xc.X编辑框_剪贴板复制(e.X句柄)
}

// 编辑框_剪贴板粘贴.
func (e *X结构_编辑框) X剪贴板粘贴() bool {
	return xc.X编辑框_剪贴板粘贴(e.X句柄)
}

// 编辑框_撤销.
func (e *X结构_编辑框) X撤销() bool {
	return xc.X编辑框_撤销(e.X句柄)
}

// 编辑框_恢复.
func (e *X结构_编辑框) X恢复() bool {
	return xc.X编辑框_恢复(e.X句柄)
}

// 编辑框_添加气泡开始, 当前行开始.
//
// hImageAvatar: 头像.
//
// hImageBubble: 气泡背景.
//
// nFlag: 标志, Chat_Flag_.
func (e *X结构_编辑框) X添加气泡开始(头像 int, 气泡背景 int, 标志 xcc.X聊天气泡行标识) *X结构_编辑框 {
	xc.X编辑框_添加气泡开始(e.X句柄, 头像, 气泡背景, 标志)
	return e
}

// 编辑框_添加气泡结束, 当前行结束.
func (e *X结构_编辑框) X添加气泡结束() *X结构_编辑框 {
	xc.X编辑框_添加气泡结束(e.X句柄)
	return e
}

// 编辑框_置气泡缩进, 设置聊天气泡内容缩进.
//
// nIndentation: 缩进值.
func (e *X结构_编辑框) X设置气泡缩进(缩进值 int32) *X结构_编辑框 {
	xc.X编辑框_设置气泡缩进(e.X句柄, 缩进值)
	return e
}

// 编辑框_置行间隔, 设置行间隔大小, 多行模式有效.
//
// nSpace: 行间隔大小.
func (e *X结构_编辑框) X设置行间隔(行间隔大小 int32) *X结构_编辑框 {
	xc.X编辑框_设置行间隔(e.X句柄, 行间隔大小)
	return e
}

// 编辑框_置当前位置扩展.
//
// iRow: 行索引.
//
// iCol: 列索引.
func (e *X结构_编辑框) X设置当前位置EX(行索引, 列索引 int32) *X结构_编辑框 {
	xc.X编辑框_设置当前位置EX(e.X句柄, 行索引, 列索引)
	return e
}

// 编辑框_取当前位置扩展.
//
// iRow: 返回行索引.
//
// iCol: 返回列索引.
func (e *X结构_编辑框) X取当前位置EX(返回行索引, 返回列索引 *int32) *X结构_编辑框 {
	xc.X编辑框_取当前位置EX(e.X句柄, 返回行索引, 返回列索引)
	return e
}

// 编辑框_移动到末尾.
func (e *X结构_编辑框) X移动到末尾() *X结构_编辑框 {
	xc.X编辑框_移动到末尾(e.X句柄)
	return e
}

// 编辑框_行列到位置, 返回位置点.
//
// iRow: 行索引.
//
// iCol: 列索引.
func (e *X结构_编辑框) X行列到位置(行索引, 列索引 int32) int32 {
	return xc.X编辑框_行列到位置(e.X句柄, 行索引, 列索引)
}

// 编辑框_置后备字体, 置中文字体. 如果已设置, 当遇到中文字符时使用后备字体, 解决不支持中文的字体的问题
//
// hFont: 字体.
func (e *X结构_编辑框) X设置后备字体(字体 int) *X结构_编辑框 {
	xc.X编辑框_设置后备字体(e.X句柄, 字体)
	return e
}

// 编辑框_释放样式.
//
// iStyle: 样式.
func (e *X结构_编辑框) X释放样式(样式 int32) bool {
	return xc.X编辑框_释放样式(e.X句柄, 样式)
}

// 编辑框_修改样式.
//
// iStyle: 样式索引.
//
// hFont: 字体句柄.
//
// color: xc.RGBA 颜色.
//
// bColor: 是否使用颜色.
func (e *X结构_编辑框) X修改样式(样式索引 int32, 字体句柄 int, ABGR颜色 int, 是否使用颜色 bool) bool {
	return xc.X编辑框_修改样式(e.X句柄, 样式索引, 字体句柄, ABGR颜色, 是否使用颜色)
}

// 编辑框_置空格大小.
//
// size: 空格大小.
func (e *X结构_编辑框) X设置空格大小(空格大小 int32) *X结构_编辑框 {
	xc.X编辑框_设置空格大小(e.X句柄, 空格大小)
	return e
}

// 编辑框_置字符间距.
//
// size: 英文字符间距大小.
//
// sizeZh: 中文字符间距大小.
func (e *X结构_编辑框) X设置字符间距(英文字符间距, 中文字符间距 int32) *X结构_编辑框 {
	xc.X编辑框_设置字符间距(e.X句柄, 英文字符间距, 中文字符间距)
	return e
}

// 编辑框_取选择文本长度, 不包括非文本内容, 返回文本内容长度.
func (e *X结构_编辑框) X取选择文本长度() int32 {
	return xc.X编辑框_取选择文本长度(e.X句柄)
}

// 编辑框_置选择文本样式.
//
// iStyle: 样式索引.
func (e *X结构_编辑框) X设置选择文本样式(样式索引 int32) *X结构_编辑框 {
	xc.X编辑框_设置选择文本样式(e.X句柄, 样式索引)
	return e
}

// 编辑框_取文本_临时, 不包含非文本内容. 返回临时文本, 临时缓存区大小: xcc.Text_Buffer_Size .
func (e *X结构_编辑框) X取文本Tmp() string {
	return xc.X编辑框_取文本Tmp(e.X句柄)
}

// 编辑框_取文本行_临时, 获取指定行文本内容. 返回临时文本, 临时缓存区大小: xcc.Text_Buffer_Size .
//
// iRow: 行索引.
func (e *X结构_编辑框) X取行文本Tmp(行索引 int32) string {
	return xc.X编辑框_取文本行Tmp(e.X句柄, 行索引)
}

// 编辑框_取选择文本, 不包含非文本内容. 返回临时文本, 临时缓存区大小: xcc.Text_Buffer_Size .
func (e *X结构_编辑框) X取选择文本Tmp() string {
	return xc.X编辑框_取选择文本Tmp(e.X句柄)
}

// 编辑框_插入气泡开始, 当前行开始.
//
// hImageAvatar: 头像图片句柄.
//
// hImageBubble: 气泡背景图片句柄.
//
// nFlag: 聊天气泡对齐方式: xcc.Chat_Flag_ .
func (e *X结构_编辑框) X插入气泡开始(头像图片句柄 int, 背景图片句柄 int, 对齐方式 xcc.X聊天气泡行标识) *X结构_编辑框 {
	xc.X编辑框_插入气泡开始(e.X句柄, 头像图片句柄, 背景图片句柄, 对齐方式)
	return e
}

// 编辑框_取指定行气泡标识. 返回行标识: xcc.Chat_Flag_
//
// iRow: 行索引.
func (e *X结构_编辑框) X取指定行气泡标识(行索引 int32) xcc.X聊天气泡行标识 {
	return xc.X编辑框_取指定行气泡标识(e.X句柄, 行索引)
}

// 编辑框_插入文本扩展.
//
// iRow: 行索引.
//
// iCol: 列索引.
//
// pString: 字符串.
//
// iStyle: 样式.
func (e *X结构_编辑框) X插入文本EX(行索引, 列索引 int32, 文本 string, 样式 int32) *X结构_编辑框 {
	xc.X编辑框_插入文本EX(e.X句柄, 行索引, 列索引, 文本, 样式)
	return e
}

// 编辑框_插入对象.
//
// iRow: 行索引.
//
// iCol: 列索引.
//
// hObj: 对象句柄.
func (e *X结构_编辑框) X插入对象(行索引, 列索引 int32, 对象句柄 int) *X结构_编辑框 {
	xc.X编辑框_插入对象(e.X句柄, 行索引, 列索引, 对象句柄)
	return e
}

// 编辑框_置气泡最大宽度. 当值为0时代表不限制宽度.
//
// nWidth: 最大宽度.
func (e *X结构_编辑框) X设置气泡最大宽度(最大宽度 int32) *X结构_编辑框 {
	xc.X编辑框_设置气泡最大宽度(e.X句柄, 最大宽度)
	return e
}

// 编辑框_取总行数扩展. 包含自动换行数量, 返回总行数.
func (e *X结构_编辑框) X取总行数EX() int32 {
	return xc.X编辑框_取总行数EX(e.X句柄)
}

// 编辑框_剪贴板复制. 复制全部内容.
func (e *X结构_编辑框) X复制剪贴板() bool {
	return xc.X编辑框_剪贴板复制全部(e.X句柄)
}

// ------------------------- 事件 ------------------------- //

type X事件_编辑框_设置 func(pbHandled *bool) int                                       // 元素事件_编辑框设置.
type X事件_编辑框_设置1 func(hEle int, pbHandled *bool) int                            // 元素事件_编辑框设置.
type X事件_编辑框_暂未使用 func(hDraw int, iRow int32, pbHandled *bool) int            // 暂未使用.
type X事件_编辑框_暂未使用1 func(hEle int, hDraw int, iRow int32, pbHandled *bool) int // 暂未使用.
type X事件_编辑框_内容被改变 func(pbHandled *bool) int                                   // 编辑框_内容被改变.
type X事件_编辑框_内容被改变1 func(hEle int, pbHandled *bool) int                        // 编辑框_内容被改变.
type X事件_编辑框_光标位置被改变 func(iPos int32, pbHandled *bool) int                   // 编辑框_光标位置_被改变.
type X事件_编辑框_光标位置被改变1 func(hEle int, iPos int32, pbHandled *bool) int        // 编辑框_光标位置_被改变.
type X事件_编辑框_样式被改变 func(iStyle int32, pbHandled *bool) int               // 编辑框_样式_被改变.
type X事件_编辑框_样式被改变1 func(hEle int, iStyle int32, pbHandled *bool) int    // 编辑框_样式_被改变.
type X事件_编辑框_回车TAB对齐 func(pbHandled *bool) int                        // 回车TAB对齐,返回需要TAB数量.
type X事件_编辑框_回车TAB对齐1 func(hEle int, pbHandled *bool) int             // 回车TAB对齐,返回需要TAB数量.
// 编辑框_行_被改变.
//
// iRow: 更改行开始位置索引,  if(nChangeRows>0) iEnd= iRow + nChangeRows
//
// nChangeRows: 改变行数, 正数添加行, 负数删除行
type X事件_编辑框_行被改变 func(iRow int32, nChangeRows int32, pbHandled *bool) int

// 编辑框_行_被改变.
//
// iRow: 更改行开始位置索引,  if(nChangeRows>0) iEnd= iRow + nChangeRows
//
// nChangeRows: 改变行数, 正数添加行, 负数删除行
type X事件_编辑框_行被改变1 func(hEle int, iRow int32, nChangeRows int32, pbHandled *bool) int
type X事件_编辑框_交换行 func(iRow, bArrowUp int32, pbHandled *bool) int            // 元素事件_交换行
type X事件_编辑框_交换行1 func(hEle int, iRow, bArrowUp int32, pbHandled *bool) int // 元素事件_交换行
type X事件_编辑框_颜色被改变 func(color int, pbHandled *bool) int                  // 编辑框_颜色被改变
type X事件_编辑框_颜色被改变1 func(hEle int, color int, pbHandled *bool) int       // 编辑框_颜色被改变

// 编辑框_颜色被改变.
func (e *X结构_编辑框) X事件_颜色被改变(回调函数 X事件_编辑框_颜色被改变) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_编辑框_颜色被改变, 回调函数)
}

// 编辑框_颜色被改变.
func (e *X结构_编辑框) X事件_颜色被改变1(回调函数 X事件_编辑框_颜色被改变1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_编辑框_颜色被改变, 回调函数)
}

// 元素事件_交换行.
func (e *X结构_编辑框) X事件_交换行(回调函数 X事件_编辑框_交换行) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_编辑框_交换行, 回调函数)
}

// 元素事件_交换行.
func (e *X结构_编辑框) X事件_交换行1(回调函数 X事件_编辑框_交换行1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_编辑框_交换行, 回调函数)
}

// 元素事件_编辑框设置.
func (e *X结构_编辑框) X事件_编辑框设置(回调函数 X事件_编辑框_设置) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_编辑框_编辑框设置, 回调函数)
}

// 元素事件_编辑框设置.
func (e *X结构_编辑框) X事件_编辑框设置1(回调函数 X事件_编辑框_设置1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_编辑框_编辑框设置, 回调函数)
}

// 暂未使用.
func (e *X结构_编辑框) X暂未使用Event_EDIT_DRAWROW(回调函数 X事件_编辑框_暂未使用) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_编辑框_暂未使用, 回调函数)
}

// 暂未使用.
func (e *X结构_编辑框) X暂未使用Event_EDIT_DRAWROW1(回调函数 X事件_编辑框_暂未使用1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_编辑框_暂未使用, 回调函数)
}

// 编辑框_内容被改变.
func (e *X结构_编辑框) X事件_内容被改变(回调函数 X事件_编辑框_内容被改变) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_编辑框_内容被改变, 回调函数)
}

// 编辑框_内容被改变.
func (e *X结构_编辑框) X事件_内容被改变1(回调函数 X事件_编辑框_内容被改变1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_编辑框_内容被改变, 回调函数)
}

// 编辑框_光标位置_被改变.
func (e *X结构_编辑框) X事件_光标位置被改变(回调函数 X事件_编辑框_光标位置被改变) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_编辑框_光标位置被改变, 回调函数)
}

// 编辑框_光标位置_被改变.
func (e *X结构_编辑框) X事件_光标位置被改变1(回调函数 X事件_编辑框_光标位置被改变1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_编辑框_光标位置被改变, 回调函数)
}

// 编辑框_样式_被改变.
func (e *X结构_编辑框) X事件_样式被改变(回调函数 X事件_编辑框_样式被改变) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_编辑框_样式被改变, 回调函数)
}

// 编辑框_样式_被改变.
func (e *X结构_编辑框) X事件_样式被改变1(回调函数 X事件_编辑框_样式被改变1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_编辑框_样式被改变, 回调函数)
}

// 回车TAB对齐,返回需要TAB数量.
func (e *X结构_编辑框) X事件_回车TAB对齐(回调函数 X事件_编辑框_回车TAB对齐) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_编辑框_回车TAB对齐, 回调函数)
}

// 回车TAB对齐,返回需要TAB数量.
func (e *X结构_编辑框) X事件_回车TAB对齐1(回调函数 X事件_编辑框_回车TAB对齐1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_编辑框_回车TAB对齐, 回调函数)
}

// 编辑框_行_被改变.
//
// iRow: 更改行开始位置索引,  if(nChangeRows>0) iEnd= iRow + nChangeRows
//
// nChangeRows: 改变行数, 正数添加行, 负数删除行
func (e *X结构_编辑框) X事件_行被改变(回调函数 X事件_编辑框_行被改变) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_编辑框_行被改变, 回调函数)
}

// 编辑框_行_被改变.
//
// iRow: 更改行开始位置索引,  if(nChangeRows>0) iEnd= iRow + nChangeRows
//
// nChangeRows: 改变行数, 正数添加行, 负数删除行
func (e *X结构_编辑框) X事件_行被改变1(回调函数 X事件_编辑框_行被改变1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_编辑框_行被改变, 回调函数)
}

// ------------------------- AddEvent ------------------------- //

// AddEvent_Edit_Set 添加编辑框设置事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_编辑框) AddEvent_Edit_Set(pFun X事件_编辑框_设置1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_编辑框_编辑框设置, onXE_EDIT_SET, pFun, allowAddingMultiple...)
}

// onXE_EDIT_SET 编辑框设置事件.
func onXE_EDIT_SET(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_编辑框_编辑框设置)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_编辑框_设置1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Edit_DrawRow 添加编辑框绘制行事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_编辑框) AddEvent_Edit_DrawRow(pFun X事件_编辑框_暂未使用1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_编辑框_暂未使用, onXE_EDIT_DRAWROW, pFun, allowAddingMultiple...)
}

// onXE_EDIT_DRAWROW 编辑框绘制行事件.
func onXE_EDIT_DRAWROW(hEle int, hDraw int, iRow int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_编辑框_暂未使用)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_编辑框_暂未使用1)(hEle, hDraw, iRow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Edit_Changed 添加编辑框内容被改变事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_编辑框) AddEvent_Edit_Changed(pFun X事件_编辑框_内容被改变1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_编辑框_内容被改变, onXE_EDIT_CHANGED, pFun, allowAddingMultiple...)
}

// onXE_EDIT_CHANGED 编辑框内容被改变事件.
func onXE_EDIT_CHANGED(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_编辑框_内容被改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_编辑框_内容被改变1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Edit_Pos_Changed 添加编辑框光标位置被改变事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_编辑框) AddEvent_Edit_Pos_Changed(pFun X事件_编辑框_光标位置被改变1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_编辑框_光标位置被改变, onXE_EDIT_POS_CHANGED, pFun, allowAddingMultiple...)
}

// onXE_EDIT_POS_CHANGED 编辑框光标位置被改变事件.
func onXE_EDIT_POS_CHANGED(hEle int, iPos int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_编辑框_光标位置被改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_编辑框_光标位置被改变1)(hEle, iPos, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Edit_Style_Changed 添加编辑框样式被改变事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_编辑框) AddEvent_Edit_Style_Changed(pFun X事件_编辑框_样式被改变1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_编辑框_样式被改变, onXE_EDIT_STYLE_CHANGED, pFun, allowAddingMultiple...)
}

// onXE_EDIT_STYLE_CHANGED 编辑框样式被改变事件.
func onXE_EDIT_STYLE_CHANGED(hEle int, iStyle int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_编辑框_样式被改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_编辑框_样式被改变1)(hEle, iStyle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Edit_Enter_Get_TabAlign 添加编辑框回车TAB对齐事件, 返回需要TAB数量.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_编辑框) AddEvent_Edit_Enter_Get_TabAlign(pFun X事件_编辑框_回车TAB对齐1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_编辑框_回车TAB对齐, onXE_EDIT_ENTER_GET_TABALIGN, pFun, allowAddingMultiple...)
}

// onXE_EDIT_ENTER_GET_TABALIGN 编辑框回车TAB对齐事件.
func onXE_EDIT_ENTER_GET_TABALIGN(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_编辑框_回车TAB对齐)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_编辑框_回车TAB对齐1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Edit_Row_Changed 添加编辑框行被改变事件.
//   - iRow: 更改行开始位置索引, if(nChangeRows>0) iEnd= iRow + nChangeRows
//   - nChangeRows: 改变行数, 正数添加行, 负数删除行
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_编辑框) AddEvent_Edit_Row_Changed(pFun X事件_编辑框_行被改变1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_编辑框_行被改变, onXE_EDIT_ROW_CHANGED, pFun, allowAddingMultiple...)
}

// onXE_EDIT_ROW_CHANGED 编辑框行被改变事件.
func onXE_EDIT_ROW_CHANGED(hEle int, iRow int32, nChangeRows int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_编辑框_行被改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_编辑框_行被改变1)(hEle, iRow, nChangeRows, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Edit_SwapRow 添加编辑框交换行事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_编辑框) AddEvent_Edit_SwapRow(pFun X事件_编辑框_交换行1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_编辑框_交换行, onXE_EDIT_SWAPROW, pFun, allowAddingMultiple...)
}

// onXE_EDIT_SWAPROW 编辑框交换行事件.
func onXE_EDIT_SWAPROW(hEle int, iRow int32, bArrowUp int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_编辑框_交换行)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_编辑框_交换行1)(hEle, iRow, bArrowUp, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Edit_Color_Change 添加编辑框颜色被改变事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_编辑框) AddEvent_Edit_Color_Change(pFun X事件_编辑框_颜色被改变1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_编辑框_颜色被改变, onXE_EDIT_COLOR_CHANGE, pFun, allowAddingMultiple...)
}

// onXE_EDIT_COLOR_CHANGE 编辑框颜色被改变事件.
func onXE_EDIT_COLOR_CHANGE(hEle int, color int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_编辑框_颜色被改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_编辑框_颜色被改变1)(hEle, color, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}
